
#include <cstdint>
#include <memory>
#include <string.h>
#include "someip/someip_signals.h"
#include "someip/someip_structs.h"
#include "ConvertSomeIP2Signal.h"

namespace ecarx::transfer::someip{
    
    std::vector<Signal> someipToSignals(const std::shared_ptr<vsomeip::message> response){
        std::vector<Signal> signals={};
        auto methodId=response->get_method();
        vsomeip::service_t serviceid=response->get_service();
        switch((uint32_t)serviceid){

            case ADCU_HMI_SERVICE_ID:{
                switch(methodId){

                    
                    case SettingDrivingInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingDrivingInfoInf;
                        SettingDrivingInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingDrivingInfoInfEventId);
                        SettingDrivingInfoInf.mode = NotifyMode::ValueChanged;
                        SettingDrivingInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingDrivingInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingDrivingInfoInf);
                        break;
                    }
                    
                    case SettingAEBInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingAEBInfoInf;
                        SettingAEBInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingAEBInfoInfEventId);
                        SettingAEBInfoInf.mode = NotifyMode::ValueChanged;
                        SettingAEBInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingAEBInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingAEBInfoInf);
                        break;
                    }
                    
                    case SettingLKAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingLKAInfoInf;
                        SettingLKAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingLKAInfoInfEventId);
                        SettingLKAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingLKAInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingLKAInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingLKAInfoInf);
                        break;
                    }
                    
                    case SettingFCTAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingFCTAInfoInf;
                        SettingFCTAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingFCTAInfoInfEventId);
                        SettingFCTAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingFCTAInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingFCTAInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingFCTAInfoInf);
                        break;
                    }
                    
                    case SettingRCTAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingRCTAInfoInf;
                        SettingRCTAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingRCTAInfoInfEventId);
                        SettingRCTAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingRCTAInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingRCTAInfoInf);
                        break;
                    }
                    
                    case SettingDOWInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingDOWInfoInf;
                        SettingDOWInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingDOWInfoInfEventId);
                        SettingDOWInfoInf.mode = NotifyMode::ValueChanged;
                        SettingDOWInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingDOWInfoInf);
                        break;
                    }
                    
                    case SettingBSDInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingBSDInfoInf;
                        SettingBSDInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingBSDInfoInfEventId);
                        SettingBSDInfoInf.mode = NotifyMode::ValueChanged;
                        SettingBSDInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingBSDInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingBSDInfoInf);
                        break;
                    }
                    
                    case SettingTSIInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingTSIInfoInf;
                        SettingTSIInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingTSIInfoInfEventId);
                        SettingTSIInfoInf.mode = NotifyMode::ValueChanged;
                        SettingTSIInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingTSIInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingTSIInfoInf);
                        break;
                    }
                    
                    case SettingSRVInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingSRVInfoInf;
                        SettingSRVInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingSRVInfoInfEventId);
                        SettingSRVInfoInf.mode = NotifyMode::ValueChanged;
                        SettingSRVInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingSRVInfoInf);
                        break;
                    }
                    
                    case SettingEMAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingEMAInfoInf;
                        SettingEMAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingEMAInfoInfEventId);
                        SettingEMAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingEMAInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingEMAInfoInf);
                        break;
                    }
                    
                    case SettingTLAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingTLAInfoInf;
                        SettingTLAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingTLAInfoInfEventId);
                        SettingTLAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingTLAInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingTLAInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingTLAInfoInf);
                        break;
                    }
                    
                    case SettingCMSRInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingCMSRInfoInf;
                        SettingCMSRInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingCMSRInfoInfEventId);
                        SettingCMSRInfoInf.mode = NotifyMode::ValueChanged;
                        SettingCMSRInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingCMSRInfoInf);
                        break;
                    }
                    
                    case SettingVoiceWarningInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingVoiceWarningInfoInf;
                        SettingVoiceWarningInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingVoiceWarningInfoInfEventId);
                        SettingVoiceWarningInfoInf.mode = NotifyMode::ValueChanged;
                        SettingVoiceWarningInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingVoiceWarningInfoInf);
                        break;
                    }
                    
                    case SettingAPAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingAPAInfoInf;
                        SettingAPAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingAPAInfoInfEventId);
                        SettingAPAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingAPAInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingAPAInfoInf);
                        break;
                    }
                    
                    case SettingRPAInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingRPAInfoInf;
                        SettingRPAInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingRPAInfoInfEventId);
                        SettingRPAInfoInf.mode = NotifyMode::ValueChanged;
                        SettingRPAInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingRPAInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingRPAInfoInf);
                        break;
                    }
                    
                    case SettingLPInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingLPInfoInf;
                        SettingLPInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingLPInfoInfEventId);
                        SettingLPInfoInf.mode = NotifyMode::ValueChanged;
                        SettingLPInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingLPInfoInf);
                        break;
                    }
                    
                    case SelectedSlotIdInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SelectedSlotIdInf;
                        SelectedSlotIdInf.signalId=static_cast<uint32_t>(SOMEIPRX::SelectedSlotIdInfEventId);
                        SelectedSlotIdInf.mode = NotifyMode::ValueChanged;
                        SelectedSlotIdInf.value.int32Values={(int32_t)buffer[0]|(buffer[1] & 0xFF)<<8|(buffer[2] & 0xFF)<<16|(buffer[3] & 0xFF)<<24};
                        signals.push_back(SelectedSlotIdInf);
                        break;
                    }
                    
                    case AlarmInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal AlarmInfoInf;
                        AlarmInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::AlarmInfoInfEventId);
                        AlarmInfoInf.mode = NotifyMode::ValueChanged;
                        AlarmInfoInf.value.bytes.resize(realLen);
                        memcpy(AlarmInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(AlarmInfoInf);
                        break;
                    }
                    
                    case FaultListInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal FaultListInfoInf;
                        FaultListInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::FaultListInfoInfEventId);
                        FaultListInfoInf.mode = NotifyMode::ValueChanged;
                        FaultListInfoInf.value.bytes.resize(realLen);
                        memcpy(FaultListInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(FaultListInfoInf);
                        break;
                    }
                    
                    case FeatureStateInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal FeatureStateInf;
                        FeatureStateInf.signalId=static_cast<uint32_t>(SOMEIPRX::FeatureStateInfEventId);
                        FeatureStateInf.mode = NotifyMode::ValueChanged;
                        FeatureStateInf.value.bytes.resize(realLen);
                        memcpy(FeatureStateInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(FeatureStateInf);
                        break;
                    }
                    
                    case HighDefinitionMapInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal HighDefinitionMapInf;
                        HighDefinitionMapInf.signalId=static_cast<uint32_t>(SOMEIPRX::HighDefinitionMapInfEventId);
                        HighDefinitionMapInf.mode = NotifyMode::ValueChanged;
                        HighDefinitionMapInf.value.bytes.resize(realLen);
                        memcpy(HighDefinitionMapInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(HighDefinitionMapInf);
                        break;
                    }
                    
                    case PercepFusionObjsInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal PercepFusionObjsInf;
                        PercepFusionObjsInf.signalId=static_cast<uint32_t>(SOMEIPRX::PercepFusionObjsInfEventId);
                        PercepFusionObjsInf.mode = NotifyMode::ValueChanged;
                        PercepFusionObjsInf.value.bytes.resize(realLen);
                        memcpy(PercepFusionObjsInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(PercepFusionObjsInf);
                        break;
                    }
                    
                    case PerceptionAPASlotsInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal PerceptionAPASlotsInf;
                        PerceptionAPASlotsInf.signalId=static_cast<uint32_t>(SOMEIPRX::PerceptionAPASlotsInfEventId);
                        PerceptionAPASlotsInf.mode = NotifyMode::ValueChanged;
                        PerceptionAPASlotsInf.value.bytes.resize(realLen);
                        memcpy(PerceptionAPASlotsInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(PerceptionAPASlotsInf);
                        break;
                    }
                    
                    case PercepTrafficLightsInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal PercepTrafficLightsInf;
                        PercepTrafficLightsInf.signalId=static_cast<uint32_t>(SOMEIPRX::PercepTrafficLightsInfEventId);
                        PercepTrafficLightsInf.mode = NotifyMode::ValueChanged;
                        PercepTrafficLightsInf.value.bytes.resize(realLen);
                        memcpy(PercepTrafficLightsInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(PercepTrafficLightsInf);
                        break;
                    }
                    
                    case PlanningTrajectoryInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal PlanningTrajectoryInf;
                        PlanningTrajectoryInf.signalId=static_cast<uint32_t>(SOMEIPRX::PlanningTrajectoryInfEventId);
                        PlanningTrajectoryInf.mode = NotifyMode::ValueChanged;
                        PlanningTrajectoryInf.value.bytes.resize(realLen);
                        memcpy(PlanningTrajectoryInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(PlanningTrajectoryInf);
                        break;
                    }
                    
                    case RelativeLocalizationInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal RelativeLocalizationInf;
                        RelativeLocalizationInf.signalId=static_cast<uint32_t>(SOMEIPRX::RelativeLocalizationInfEventId);
                        RelativeLocalizationInf.mode = NotifyMode::ValueChanged;
                        RelativeLocalizationInf.value.bytes.resize(realLen);
                        memcpy(RelativeLocalizationInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(RelativeLocalizationInf);
                        break;
                    }
                    
                    case AlignedSpeedSettingInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal AlignedSpeedSettingInf;
                        AlignedSpeedSettingInf.signalId=static_cast<uint32_t>(SOMEIPRX::AlignedSpeedSettingInfEventId);
                        AlignedSpeedSettingInf.mode = NotifyMode::ValueChanged;
                        AlignedSpeedSettingInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(AlignedSpeedSettingInf);
                        break;
                    }
                    
                    case PebSwitchSettingInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal PebSwitchSettingInf;
                        PebSwitchSettingInf.signalId=static_cast<uint32_t>(SOMEIPRX::PebSwitchSettingInfEventId);
                        PebSwitchSettingInf.mode = NotifyMode::ValueChanged;
                        PebSwitchSettingInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(PebSwitchSettingInf);
                        break;
                    }
                    
                    case LaneFunctionEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal LaneFunction;
                        LaneFunction.signalId=static_cast<uint32_t>(SOMEIPRX::LaneFunctionEventId);
                        LaneFunction.mode = NotifyMode::ValueChanged;
                        LaneFunction.value.bytes.resize(realLen);
                        memcpy(LaneFunction.value.bytes.data(),buffer,realLen);
                        signals.push_back(LaneFunction);
                        break;
                    }
                    
                    case AbsoluteLocalizationInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal AbsoluteLocalizationInf;
                        AbsoluteLocalizationInf.signalId=static_cast<uint32_t>(SOMEIPRX::AbsoluteLocalizationInfEventId);
                        AbsoluteLocalizationInf.mode = NotifyMode::ValueChanged;
                        AbsoluteLocalizationInf.value.bytes.resize(realLen);
                        memcpy(AbsoluteLocalizationInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(AbsoluteLocalizationInf);
                        break;
                    }
                    
                    case SettingSGWInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingSGWInfoInf;
                        SettingSGWInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingSGWInfoInfEventId);
                        SettingSGWInfoInf.mode = NotifyMode::ValueChanged;
                        SettingSGWInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingSGWInfoInf);
                        break;
                    }
                    
                    case SettingCheckInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingCheckInf;
                        SettingCheckInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingCheckInfEventId);
                        SettingCheckInf.mode = NotifyMode::ValueChanged;
                        SettingCheckInf.value.bytes.resize(realLen);
                        memcpy(SettingCheckInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingCheckInf);
                        break;
                    }
                    
                    case APAnobtntriSwitchInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal APAnobtntriSwitchInf;
                        APAnobtntriSwitchInf.signalId=static_cast<uint32_t>(SOMEIPRX::APAnobtntriSwitchInfEventId);
                        APAnobtntriSwitchInf.mode = NotifyMode::ValueChanged;
                        APAnobtntriSwitchInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(APAnobtntriSwitchInf);
                        break;
                    }
                    
                    case SettingRCTBInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingRCTBInfoInf;
                        SettingRCTBInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingRCTBInfoInfEventId);
                        SettingRCTBInfoInf.mode = NotifyMode::ValueChanged;
                        SettingRCTBInfoInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(SettingRCTBInfoInf);
                        break;
                    }
                    
                    case AccfushSwitchTypeEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal AccfushSwitchType;
                        AccfushSwitchType.signalId=static_cast<uint32_t>(SOMEIPRX::AccfushSwitchTypeEventId);
                        AccfushSwitchType.mode = NotifyMode::ValueChanged;
                        AccfushSwitchType.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(AccfushSwitchType);
                        break;
                    }
                    
                    case ALCAstateInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal ALCAstateInf;
                        ALCAstateInf.signalId=static_cast<uint32_t>(SOMEIPRX::ALCAstateInfEventId);
                        ALCAstateInf.mode = NotifyMode::ValueChanged;
                        ALCAstateInf.value.int32Values={(int32_t)buffer[0]|(buffer[1] & 0xFF)<<8|(buffer[2] & 0xFF)<<16|(buffer[3] & 0xFF)<<24};
                        signals.push_back(ALCAstateInf);
                        break;
                    }
                    
                    case DispTSIInfoForLgtCtrlSeNEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal DispTSIInfoForLgtCtrlSeN;
                        DispTSIInfoForLgtCtrlSeN.signalId=static_cast<uint32_t>(SOMEIPRX::DispTSIInfoForLgtCtrlSeNEventId);
                        DispTSIInfoForLgtCtrlSeN.mode = NotifyMode::ValueChanged;
                        DispTSIInfoForLgtCtrlSeN.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(DispTSIInfoForLgtCtrlSeN);
                        break;
                    }
                    
                    case TSISpeedLimitUnitIconSeNEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal TSISpeedLimitUnitIconSeN;
                        TSISpeedLimitUnitIconSeN.signalId=static_cast<uint32_t>(SOMEIPRX::TSISpeedLimitUnitIconSeNEventId);
                        TSISpeedLimitUnitIconSeN.mode = NotifyMode::ValueChanged;
                        TSISpeedLimitUnitIconSeN.value.int32Values={(int32_t)buffer[0]|(buffer[1] & 0xFF)<<8|(buffer[2] & 0xFF)<<16|(buffer[3] & 0xFF)<<24};
                        signals.push_back(TSISpeedLimitUnitIconSeN);
                        break;
                    }
                    
                    case APAparkinfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal APAparkinfoInf;
                        APAparkinfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::APAparkinfoInfEventId);
                        APAparkinfoInf.mode = NotifyMode::ValueChanged;
                        APAparkinfoInf.value.bytes.resize(realLen);
                        memcpy(APAparkinfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(APAparkinfoInf);
                        break;
                    }
                    
                    case BigdataSpdLimSwitchInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal BigdataSpdLimSwitchInf;
                        BigdataSpdLimSwitchInf.signalId=static_cast<uint32_t>(SOMEIPRX::BigdataSpdLimSwitchInfEventId);
                        BigdataSpdLimSwitchInf.mode = NotifyMode::ValueChanged;
                        BigdataSpdLimSwitchInf.value.int32Values={(int32_t)buffer[0]};
                        signals.push_back(BigdataSpdLimSwitchInf);
                        break;
                    }
                    
                    case SettingAEBFCWInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        uint32_t realLen = response->get_payload()->get_length();
                        Signal SettingAEBFCWInfoInf;
                        SettingAEBFCWInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingAEBFCWInfoInfEventId);
                        SettingAEBFCWInfoInf.mode = NotifyMode::ValueChanged;
                        SettingAEBFCWInfoInf.value.bytes.resize(realLen);
                        memcpy(SettingAEBFCWInfoInf.value.bytes.data(),buffer,realLen);
                        signals.push_back(SettingAEBFCWInfoInf);
                        break;
                    }
                    
                    case SettingRCTABInfoInfEvent:{
                        uint8_t* buffer=static_cast<uint8_t*>(response->get_payload()->get_data());

                        Signal SettingRCTABInfoInf;
                        SettingRCTABInfoInf.signalId=static_cast<uint32_t>(SOMEIPRX::SettingRCTABInfoInfEventId);
                        SettingRCTABInfoInf.mode = NotifyMode::ValueChanged;
                        SettingRCTABInfoInf.value.int32Values={(int32_t)buffer[0]|(buffer[1] & 0xFF)<<8|(buffer[2] & 0xFF)<<16|(buffer[3] & 0xFF)<<24};
                        signals.push_back(SettingRCTABInfoInf);
                        break;
                    }
                }
                break;
            }
        }
        return signals;
    }
}
